home *** CD-ROM | disk | FTP | other *** search
/ Eagles Nest BBS 8 / Eagles_Nest_Mac_Collection_Disc_8.TOAST / Developer Tools⁄Additions / MacUserProj / MacUser Projects / June / 2GenApp Src / MiscUtil.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-04-25  |  8.0 KB  |  357 lines  |  [TEXT/KAHL]
  1. /* *****************************************************************************
  2.     FILE:             MiscUtil.c
  3.     
  4.     DESCRIPTION:     Useful utilities
  5.  
  6.     AUTHOR:            Kurt W.G. Matthies
  7.         
  8.     Copyright © 1990 by Code of the West, Inc., All Rights Reserved.
  9.     
  10.     
  11.     Revision History:
  12.     ==========================================================
  13.     4.24.90 -    June 1990 MacUser Release - Multiple window support
  14.     3.30.90    -    May 1990 MacUser Release
  15.     ==========================================================
  16.  
  17.    ***************************************************************************** */
  18. #include "Version.h"
  19.  
  20. #ifdef V4
  21. #include <stdio.h>
  22. #endif
  23.  
  24. #ifdef V3
  25. #include <Proto.h>
  26. #endif
  27.  
  28. #ifdef V2
  29. #include <asm.h>
  30. #include <Pascal.h>
  31. #include <Proto.h>
  32. #endif
  33.  
  34. #include "AppGlobals.h"
  35. #include "StrRsrcDefs.h"
  36.  
  37. #include "DialogUtilPr.h"
  38. #include "WindowUtilPr.h"
  39.  
  40. #include "MiscUtilPr.h"
  41.  
  42. /* -------------------------------------------------------------------------
  43.     newClearPtr -     allocate a zeroed, non-relocatable memory object of size 
  44.     3.30.90kwgm        bytes and return its pointer
  45. ---------------------------------------------------------------------------- */
  46. Ptr
  47. newClearPtr (size)
  48.     Size            size;
  49. {
  50.     Ptr                thePtr;
  51.     Size            freeMem;
  52.     OSErr            err;
  53.     Str64            s;
  54.     
  55.     thePtr = 0L;
  56.     if (size >= 0L)        /* a common sense test for negative size */
  57.     {
  58.         freeMem = MaxBlock ();        /* check the largest block avail */
  59.     
  60.         if (size < freeMem)        /* if request is less than largest block */
  61.         {
  62.             /* use "glue" to allocate the zeroed memory */
  63.             asm
  64.             {
  65.                 move.l        size, d0
  66.                 NewPtr      CLEAR
  67.                 move.l        a0, thePtr
  68.             }
  69.     
  70.             if (err = MemError())    /* test for success */
  71.             {
  72.                 if (gDevel)
  73.                 {
  74.                     memErrorStr (s, err);
  75.                     pDebugStr (s);            /* report error */
  76.                 }
  77.         
  78.                 thePtr = 0L;    /* clear out the ptr on memory error */
  79.             }
  80.         }
  81.     }
  82.     else
  83.     {
  84.         if (gDevel)
  85.             pDebugStr ("\pnewClearPtr: negative size");
  86.     }
  87.     
  88.     return (thePtr);
  89.         
  90. } /* newClearPtr */
  91.  
  92. /*---------------------------------------------------------------------------
  93.     newClearHdl -     allocate a zeroed, relocatable memory object of size 
  94.     4.24.90kwgm        bytes and return the handle to it
  95. ----------------------------------------------------------------------------*/
  96. Handle
  97. newClearHdl (size)
  98.     Size            size;
  99. {
  100.     Ptr                theHandle;
  101.     Size            freeMem;
  102.     OSErr            err;
  103.     Str64            s;
  104.     
  105.     theHandle = 0L;
  106.     if (size >= 0L)
  107.     {
  108.         freeMem = FreeMem ();    /* check free space */
  109.         if (size < freeMem)        /* if less than free space */
  110.         {
  111.             /* use "glue" to allocate the zeroed memory */
  112.             asm
  113.             {
  114.                 move.l        size, d0
  115.                 NewHandle    CLEAR
  116.                 move.l        a0, theHandle
  117.             }
  118.     
  119.             if (err = MemError())    /* test for success */
  120.             {
  121.                 if (gDevel)
  122.                 {
  123.                     memErrorStr (s, err);
  124.                     pDebugStr (s);
  125.                 }
  126.         
  127.                 theHandle = 0L;    /* clear out the handle on memory error */
  128.             }
  129.         }
  130.     }
  131.     else
  132.     {
  133.         if (gDevel)
  134.             pDebugStr ("\pnewClearHdl: negative size");
  135.     }
  136.     
  137.     return (theHandle);
  138.         
  139. } /* newClearHdl */
  140.  
  141. /* ---------------------------------------------------------------------------------
  142.     resizeHdl -        resize a relocatable block of memory
  143.     4.24.90kwgm
  144. ------------------------------------------------------------------------------------ */
  145. OSErr
  146. resizeHdl (aHandle, newSize)
  147.     Handle        aHandle;
  148.     Size        newSize;
  149. {
  150.     OSErr        err;
  151.     Size        free, size;
  152.     Str64        s;
  153.     
  154.     if (newSize < 0L)
  155.     {
  156.         if (gDevel)
  157.             pDebugStr ("\presizeHdl: requested handle size is negative");
  158.             
  159.         return (nilHandleErr);
  160.     }
  161.  
  162.     if (aHandle)
  163.     {
  164.         /* odd address handles are not allowed (yet!) */
  165.         if ((long)aHandle & 0x00000001L)
  166.         {
  167.             if (gDevel)
  168.                 pDebugStr ("\presizeHdl: Handle has odd address");
  169.  
  170.             return (nilHandleErr);
  171.         }
  172.  
  173.         /* is this handle a real handle?? 
  174.             GetHandleSize returns 0 if it isn't
  175.         */
  176.         size = GetHandleSize (aHandle);
  177.         if (!size)
  178.         {
  179.             /* if MemError then we have a bad handle */
  180.             if (err = MemError ())
  181.             {
  182.                 if (gDevel)
  183.                 {
  184.                     memErrorStr (s, err);
  185.                     pDebugStr (s);
  186.                 }
  187.                 return (err);
  188.             }
  189.         }
  190.     
  191.         /* change the size */
  192.         SetHandleSize (aHandle, newSize);
  193.  
  194.         /* check error in SetHandleSize */
  195.         if (err = MemError())
  196.         {
  197.             memErrorStr (s, err);
  198.             pDebugStr (s);
  199.             return (err);
  200.         }
  201.     }
  202.     else
  203.     {
  204.         pDebugStr ("\presizeHdl: attempt to resize null Handle");
  205.         return (nilHandleErr);
  206.     }
  207.         
  208.     return (noErr);
  209.             
  210. } /* resizeHdl */
  211.  
  212. /* ------------------------------------------------------------------------------------
  213.     pDebugStr  -    provide sensible interface for error messages and allow a user the
  214.     3.30.90kwgm        choice of actions
  215. --------------------------------------------------------------------------------------- */
  216. Boolean
  217. pDebugStr  (string)
  218.     StringPtr            string;
  219. {
  220.     unsigned short        flags;
  221.     short                theItem, type;
  222.     Rect                box;
  223.     GrafPtr                savePort;
  224.     ControlHandle        itemHdl;
  225.     DialogPtr             theDialog;
  226.     
  227.     SysBeep (1);            /* beep the bell */
  228.     GetPort (&savePort);    /* save graphic environment */
  229.  
  230.     /* get the dialog for the message */
  231.     if (!(theDialog = GetNewDialog (kDebugMsgDLOG, 0L, -1L)))
  232.         return (false);
  233.     
  234.     /* hilite the default button */
  235.     GetDItem (theDialog, kDebugMsgOKOutline, &type, &itemHdl, &box);
  236.     SetDItem (theDialog, kDebugMsgOKOutline, type, buttonProc, &box);
  237.  
  238.     ParamText (0L, string, 0L, 0L);        /* set up to write the error string */
  239.  
  240.     centerWindow (theDialog);
  241.     ShowHide (theDialog, true);
  242.     
  243.     /* display the dialog, wait for button */
  244.     ModalDialog (DLOGfilterProc1, &theItem);
  245.     
  246.     DisposDialog (theDialog);        /* restore environment */
  247.     SetPort (savePort);
  248.  
  249.     /* switch on user choice */
  250.     if (theItem == kDebugMsgExit)
  251.         ExitToShell();
  252.     else if (theItem == kDebugMsgCancel)
  253.         return (false);
  254.     else
  255.         return (true);
  256.     
  257. } /* pDebugStr */
  258.  
  259. /* ----------------------------------------------------------------------------
  260.     memErrorStr -    passed a memory error id, create a string with the error
  261.     4.24.90kwgm
  262. ------------------------------------------------------------------------------- */
  263. StringPtr
  264. memErrorStr (theString, errorID)
  265.     StringPtr        theString;
  266.     OSErr            errorID;
  267. {
  268.     Str64            errorStr, hdrStr;
  269.     short            strID;
  270.     
  271.     strID = 0;
  272.     switch (errorID)        /* get the string resource id for this error */
  273.     {
  274.         case memROZErr:
  275.             strID = kMemErrReadOnlyStr;
  276.             break;
  277.             
  278.         case memFullErr:
  279.             strID = kMemErrMemFullStr;
  280.             break;
  281.             
  282.         case nilHandleErr:
  283.             strID = kMemErrNilHdlStr;
  284.             break;
  285.             
  286.         case memWZErr:
  287.             strID = kMemErrFreeBlkStr;
  288.             break;
  289.             
  290.         case memPurErr:
  291.         case memLockedErr:
  292.             strID = kMemErrLockedBlkStr;
  293.             break;
  294.         
  295.         case noErr:
  296.             strID = kMemErrNoErrStr;
  297.             break;
  298.             
  299.         default:
  300.             strID = kMemErrUnknownStr;
  301.             break;
  302.     }
  303.         
  304.     /* get the strings from the resource file */
  305.     GetIndString (errorStr, kMemErrStrRsrc, strID);
  306.     GetIndString (hdrStr, kMemErrStrRsrc, kMemErrMsgStr);
  307.  
  308.     /* create the error string */
  309.     PtoCstr (hdrStr);
  310.     PtoCstr (errorStr);
  311.     sprintf (theString,"%s %d => %s", hdrStr, errorID, errorStr);
  312.     CtoPstr (theString);
  313.     
  314.     return (theString);
  315.     
  316. } /* memErrorStr */
  317.  
  318. /* -------------------------------------------------------------------------------------------
  319.     getDblClick -    check for double-click
  320.     4.24.90kwgm
  321. --------------------------------------------------------------------------------------------- */
  322. Boolean
  323. getDblClick (e)
  324.     register EventRecord     *e;
  325. {    
  326.     EventRecord             eRec;
  327.     register long            ticks, dblTime;
  328.     
  329. #define kBounds        5        /* in pixels */
  330.  
  331.     /* wait for mouse up event within dbl time range */
  332.     dblTime = (GetDblTime() >> 1);    /* tighten up double time */
  333.     do {
  334.         
  335.         ticks = TickCount ();
  336.         
  337.     } while (StillDown () && (ticks - e->when < dblTime));
  338.  
  339.     /* mouse down before timeout and within kBounds range of last mouse pt is a dblClick */
  340.     do {
  341.         ticks = TickCount ();
  342.         if (GetNextEvent (mDownMask,&eRec))    
  343.         {
  344.             /* check to see if in same rect */
  345.             if ((eRec.where.h <= e->where.h + kBounds) || (eRec.where.h <= e->where.h - kBounds) &&
  346.                 (eRec.where.v <= e->where.v + kBounds) || (eRec.where.v <= e->where.v - kBounds))
  347.                 return (true);
  348.         }
  349.     } while ((ticks - e->when < dblTime));
  350.  
  351.     return (false);
  352.     
  353. } /* getDblClick */
  354.  
  355. /* ===========================================  EOF  ========================================
  356.     Copyright © 1990 by Code of the West, Inc., All Rights Reserved.
  357. ============================================================================================ */